Sources/SessionIndexStore.swift (1)

525-528: Minor: unused ErrorBag on the Claude branch.

loadClaudeEntries does not accept an errorBag, so errors on the Claude path are silently swallowed here (consistent with scanAll, but worth a note). If future work adds error reporting to the Claude loader, remember to thread bag through; otherwise the let bag = ErrorBag() allocation is unused for .claude. Not blocking.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@Sources/SessionIndexStore.swift` around lines 525 - 528, The code creates an
unused ErrorBag instance (ErrorBag) before switching on agent and immediately
returns from the .claude branch by calling
loadClaudeEntries(needle:cwdFilter:offset:limit:), so the ErrorBag allocation is
redundant and any errors on the Claude path aren’t captured; either remove the
unused let bag = ErrorBag() or, if you intend to support error reporting for
Claude in future, modify loadClaudeEntries to accept an ErrorBag parameter and
thread bag through (also mirror how scanAll uses ErrorBag) so errors are
reported rather than silently dropped.

Sources/ContentView.swift (1)

2841-2850: Consider falling back to any available panel when focusedPanelId is nil.

When no panel is focused (e.g., the user opened the Files panel before interacting with any terminal/editor), the markdown route is skipped entirely and the file opens in an external editor, silently ignoring the openMarkdownInCmuxViewer preference. A similar pattern exists elsewhere in Workspace (e.g., openEditor(filePath:) falls back to bonsplitController.allPaneIds.first when focusedPaneId is nil) to avoid dropping requests.

If Workspace exposes an analogous first-pane/first-panel fallback, preferring it over the unconditional external-editor path would better honor the user's setting.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@Sources/ContentView.swift` around lines 2841 - 2850, The current
onOpenMarkdown closure returns early to external editor when
workspace.focusedPanelId is nil; change it to prefer any available panel by
obtaining a fallback panel id (e.g., let panelId = workspace.focusedPanelId ??
workspace.bonsplitController.allPaneIds.first or a Workspace-provided
firstPanelId) and pass that to workspace.openOrFocusMarkdownSplit(from: panelId,
filePath: path); only call PreferredEditorSettings.open(URL(fileURLWithPath:
path)) if openOrFocusMarkdownSplit returns nil. Update the code paths
referencing tabManager.selectedWorkspace, workspace.focusedPanelId,
workspace.openOrFocusMarkdownSplit(...), and PreferredEditorSettings.open(...)
accordingly.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

Sources/Workspace.swift (2)

582-599: ⚠️ Potential issue | 🟠 Major

Gate by the matched panel and cache the cwd-guarded command.

guard !isRemoteWorkspace skips local terminals that happen to live in a remote workspace; the remote check should be per matched panel. Also, this still stores raw entry.resumeCommand, so restored fresh shells can resume from the wrong cwd.

🔧 Proposed fix

     func resolveAndCacheResumeCommand(agentKey: String, pid: pid_t) {
-        guard !isRemoteWorkspace else { return }
         guard let agent = Self.sessionAgentForKey(agentKey) else { return }
         guard pid > 0 else { return }
 
         // Match PID to panel via TTY
         guard let pidTTY = Self.ttyForPID(pid) else { return }
         let matchedPanelId: UUID? = surfaceTTYNames.first(where: { $0.value == pidTTY })?.key
         guard let panelId = matchedPanelId else { return }
+        guard !remoteDetectedSurfaceIds.contains(panelId),
+              !isRemoteTerminalSurface(panelId) else {
+            cachedAgentResumeCommands.removeValue(forKey: panelId)
+            return
+        }
         let panelCwd = panelDirectories[panelId] ?? currentDirectory
         guard !panelCwd.isEmpty else { return }
 
         Task {
             let entries = await SessionIndexStore.latestEntries(agent: agent, cwd: panelCwd, limit: 1)
             guard let entry = entries.first else { return }
+            let resumeCommand = entry.resumeCommandWithCwd
             await MainActor.run {
-                self.cachedAgentResumeCommands[panelId] = entry.resumeCommand
+                guard self.panels[panelId] != nil,
+                      !(self.remoteDetectedSurfaceIds.contains(panelId) || self.isRemoteTerminalSurface(panelId)) else {
+                    return
+                }
+                self.cachedAgentResumeCommands[panelId] = resumeCommand
             }
         }
     }

Based on learnings: “always build resume commands using the cwd guard helper exposed by SessionEntry … cd <shell-quoted cwd> && <resumeCommand>” and “remote-backed terminals … omit restore/detected commands.”

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@Sources/Workspace.swift` around lines 582 - 599, The function
resolveAndCacheResumeCommand currently gates using the global isRemoteWorkspace
and stores raw entry.resumeCommand; change it to determine remote status per
matched panel (use matchedPanelId and panelDirectories) and skip caching if that
panel is remote-backed, then build and cache a guarded resume command using the
SessionEntry helper (i.e., prepend a cwd-guarding cd with proper shell-quoting
of panelCwd so the stored command is "cd <shell-quoted cwd> &&
<entry.resumeCommand>") instead of storing raw resumeCommand; use
Self.sessionAgentForKey, Self.ttyForPID, surfaceTTYNames,
SessionIndexStore.latestEntries, SessionEntry.resumeCommand and
cachedAgentResumeCommands to locate and update the code paths.

---

703-708: ⚠️ Potential issue | 🟠 Major

Keep the restore-time remote gate on initialInput.

This replays agentResumeCommand directly from the snapshot. Please also gate replay with the per-panel remote-backed snapshot flag, so an older or malformed snapshot cannot inject a local resume command into a remote startup shell.

🛡️ Proposed fix

-            let resumeInput = snapshot.terminal?.agentResumeCommand.map { $0 + "\n" }
+            let panelWasRemoteBacked = snapshot.terminal?.isRemoteBacked == true
+            let resumeInput = panelWasRemoteBacked
+                ? nil
+                : snapshot.terminal?.agentResumeCommand.map { $0 + "\n" }
             guard let terminalPanel = newTerminalSurface(
                 inPane: paneId,
                 focus: false,
                 workingDirectory: workingDirectory,
                 initialInput: resumeInput,

Based on learnings: “createPanel(from:inPane:) uses this per-panel flag … pass initialInput only for local panels.”

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@Sources/Workspace.swift` around lines 703 - 708, The code currently replays
snapshot.terminal?.agentResumeCommand into newTerminalSurface via initialInput
unconditionally; change it to only set initialInput when the panel is not
remote-backed (i.e., gate replay with the per-panel remote-backed snapshot flag
used by createPanel(from:inPane:)). Concretely, compute resumeInput only if the
snapshot/panel indicates a local panel (negate the per-panel remote-backed flag)
and pass nil for initialInput for remote-backed panels so
newTerminalSurface(inPane:focus:workingDirectory:initialInput:) never injects a
local resume command into a remote startup shell.

Sources/SessionIndexStore.swift (1)

522-534: Silently discarded errors from Codex/OpenCode loaders.

bag is populated inside loadCodexEntries/loadOpenCodeEntries on schema/open failures but is then dropped when this method returns. For the resume-caching call site that's probably fine (best-effort), but it means a broken Codex DB schema will silently yield [] and the agent will never auto-resume, with no diagnostic. Consider at least a dlog of bag.snapshot() under #if DEBUG so this failure mode is diagnosable.

🔎 Suggested diff

     nonisolated static func latestEntries(
         agent: SessionAgent, cwd: String, limit: Int = 1
     ) async -> [SessionEntry] {
         let bag = ErrorBag()
+        let results: [SessionEntry]
         switch agent {
         case .claude:
-            return await loadClaudeEntries(needle: "", cwdFilter: cwd, offset: 0, limit: limit)
+            results = await loadClaudeEntries(needle: "", cwdFilter: cwd, offset: 0, limit: limit)
         case .codex:
-            return await loadCodexEntries(needle: "", cwdFilter: cwd, offset: 0, limit: limit, errorBag: bag)
+            results = await loadCodexEntries(needle: "", cwdFilter: cwd, offset: 0, limit: limit, errorBag: bag)
         case .opencode:
-            return loadOpenCodeEntries(needle: "", cwdFilter: cwd, offset: 0, limit: limit, errorBag: bag)
+            results = loadOpenCodeEntries(needle: "", cwdFilter: cwd, offset: 0, limit: limit, errorBag: bag)
         }
+        `#if` DEBUG
+        let errs = bag.snapshot()
+        if !errs.isEmpty {
+            dlog("session.latestEntries agent=\(agent.rawValue) errors=\(errs.count) first=\(errs.first ?? "")")
+        }
+        `#endif`
+        return results
     }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@Sources/SessionIndexStore.swift` around lines 522 - 534, latestEntries
currently creates an ErrorBag (bag) and passes it to
loadCodexEntries/loadOpenCodeEntries but then discards any errors, causing
schema/open failures to be silent; update latestEntries to, under `#if` DEBUG, log
bag.snapshot() (or otherwise dlog the snapshot) after calling loadCodexEntries
and loadOpenCodeEntries so schema/open errors are visible during debugging while
preserving current return behavior; refer to the symbols latestEntries,
ErrorBag, bag.snapshot(), loadCodexEntries, loadOpenCodeEntries, and dlog/#if
DEBUG when making the change.